ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಅನಾವರಣಗೊಳಿಸುವುದು: ಇನ್ಹೆರಿಟೆನ್ಸ್ ಮಾದರಿಗಳು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ ರಚನೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ತನ್ನ ಮೂಲದಲ್ಲಿ, ದಶಕಗಳಿಂದ ವೆಬ್‌ಗೆ ಶಕ್ತಿ ನೀಡಿದ ಒಂದು ಡೈನಾಮಿಕ್ ಮತ್ತು ಬಹುಮುಖ ಭಾಷೆಯಾಗಿದೆ. ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಅದರ ಫಂಕ್ಷನಲ್ ಅಂಶಗಳು ಮತ್ತು ECMAScript 6 (ES6) ಮತ್ತು ನಂತರದ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಆಧುನಿಕ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗೆ ಪರಿಚಿತರಾಗಿದ್ದರೂ, ಭಾಷೆಯನ್ನು ನಿಜವಾಗಿಯೂ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಅದರ ಆಂತರಿಕ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಅತ್ಯಂತ ಮೂಲಭೂತವಾದರೂ, ಆಗಾಗ್ಗೆ ತಪ್ಪು ತಿಳಿಯಲಾಗುವ ಪರಿಕಲ್ಪನೆಗಳಲ್ಲಿ ಒಂದು ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಆಗಿದೆ. ಈ ಪೋಸ್ಟ್ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ, ಅದು ಹೇಗೆ ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ವಿವಿಧ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಮಾದರಿಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ, ಜಗತ್ತಿನಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನವನ್ನು ನೀಡುತ್ತದೆ.

ಅಡಿಪಾಯ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಮತ್ತು ಪ್ರಾಪರ್ಟಿಗಳು

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಬಗ್ಗೆ ಮೂಲಭೂತ ತಿಳುವಳಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸೋಣ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಬಹುತೇಕ ಎಲ್ಲವೂ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಕೀ-ವ್ಯಾಲ್ಯೂ ಜೋಡಿಗಳ ಸಂಗ್ರಹಗಳಾಗಿವೆ, ಇಲ್ಲಿ ಕೀಗಳು ಪ್ರಾಪರ್ಟಿ ಹೆಸರುಗಳು (ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ ಸಿಂಬಲ್‌ಗಳು) ಮತ್ತು ವ್ಯಾಲ್ಯೂಗಳು ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿರಬಹುದು, ಇದರಲ್ಲಿ ಇತರ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು, ಫಂಕ್ಷನ್‌ಗಳು, ಅಥವಾ ಪ್ರಿಮಿಟಿವ್ ವ್ಯಾಲ್ಯೂಗಳು ಸೇರಿವೆ.

ಒಂದು ಸರಳ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

            const person = {
  name: "Alice",
  age: 30,
  greet: function() {
    console.log(`Hello, my name is ${this.name}.`);
  }
};

console.log(person.name); // Output: Alice
person.greet();        // Output: Hello, my name is Alice.

            

              
                Copy
              
            
          

ನೀವು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರಾಪರ್ಟಿಯನ್ನು person.name ನಂತೆ ಪ್ರವೇಶಿಸಿದಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೊದಲು ಆ ಪ್ರಾಪರ್ಟಿಯನ್ನು ನೇರವಾಗಿ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲೇ ಹುಡುಕುತ್ತದೆ. ಅದು ಅಲ್ಲಿ ಸಿಗದಿದ್ದರೆ, ಅದು ಅಲ್ಲಿಗೆ ನಿಲ್ಲುವುದಿಲ್ಲ. ಇಲ್ಲಿಯೇ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ.

ಪ್ರೊಟೊಟೈಪ್ ಎಂದರೇನು?

ಪ್ರತಿಯೊಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೂ ಆಂತರಿಕ ಪ್ರಾಪರ್ಟಿ ಇರುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ [[Prototype]] ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ಮತ್ತೊಂದು ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ. ಈ ಇನ್ನೊಂದು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಮೂಲ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ನೀವು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಮತ್ತು ಆ ಪ್ರಾಪರ್ಟಿ ನೇರವಾಗಿ ಆ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಕಂಡುಬರದಿದ್ದಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ಆ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ. ಅದು ಅಲ್ಲಿಯೂ ಕಂಡುಬರದಿದ್ದರೆ, ಅದು ಪ್ರೊಟೊಟೈಪ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ನೋಡುತ್ತದೆ, ಹೀಗೆ ಒಂದು ಚೈನ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಕಂಡುಕೊಳ್ಳುವವರೆಗೆ ಅಥವಾ ಚೈನ್‌ನ ಅಂತ್ಯವನ್ನು ತಲುಪುವವರೆಗೆ ಈ ಚೈನ್ ಮುಂದುವರಿಯುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ Object.prototype ಆಗಿರುತ್ತದೆ, ಇದರ [[Prototype]] null ಆಗಿರುತ್ತದೆ. ಈ ಕಾರ್ಯವಿಧಾನವನ್ನು ಪ್ರೊಟೊಟೈಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವುದು

[[Prototype]] ಒಂದು ಆಂತರಿಕ ಸ್ಲಾಟ್ ಆಗಿದ್ದರೂ, ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಎರಡು ಪ್ರಾಥಮಿಕ ಮಾರ್ಗಗಳಿವೆ:

• Object.getPrototypeOf(obj): ಇದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಪಡೆಯಲು ಪ್ರಮಾಣಿತ ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಲಾದ ಮಾರ್ಗವಾಗಿದೆ.
• obj.__proto__: ಇದು ಬಳಕೆಯಿಂದ ತೆಗೆದುಹಾಕಲಾದ ಆದರೆ ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾದ ಅಪ್ರಮಾಣಿತ ಪ್ರಾಪರ್ಟಿಯಾಗಿದ್ದು, ಇದು ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಸಹ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಉತ್ತಮ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಮಾನದಂಡಗಳಿಗೆ ಬದ್ಧವಾಗಿರಲು ಸಾಮಾನ್ಯವಾಗಿ Object.getPrototypeOf() ಅನ್ನು ಬಳಸಲು ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ.

const person = {
  name: "Alice"
};

const personPrototype = Object.getPrototypeOf(person);
console.log(personPrototype === Object.prototype); // Output: true

// Using the deprecated __proto__
console.log(person.__proto__ === Object.prototype); // Output: true

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನ ಕಾರ್ಯವೈಖರಿ

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಮೂಲಭೂತವಾಗಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಒಂದು ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಆಗಿದೆ. ನೀವು ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ (get, set, or delete), ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಈ ಚೈನ್ ಅನ್ನು ಕ್ರಮಿಸುತ್ತದೆ:

1. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೊದಲು ಪ್ರಾಪರ್ಟಿ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲೇ ನೇರವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
2. ಕಂಡುಬರದಿದ್ದರೆ, ಅದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ (obj.[[Prototype]]).
3. ಇನ್ನೂ ಕಂಡುಬರದಿದ್ದರೆ, ಅದು ಪ್ರೊಟೊಟೈಪ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಹೀಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.
4. ಪ್ರಾಪರ್ಟಿಯು ಕಂಡುಬರುವವರೆಗೆ ಅಥವಾ ಪ್ರೊಟೊಟೈಪ್ null ಆಗಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ (ಸಾಮಾನ್ಯವಾಗಿ Object.prototype) ಚೈನ್ ಕೊನೆಗೊಳ್ಳುವವರೆಗೆ ಇದು ಮುಂದುವರಿಯುತ್ತದೆ.

ಒಂದು ಉದಾಹರಣೆಯೊಂದಿಗೆ ಇದನ್ನು ವಿವರಿಸೋಣ. ನಮ್ಮಲ್ಲಿ ಒಂದು ಬೇಸ್ `Animal` ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಮತ್ತು ನಂತರ `Animal` ನಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುವ `Dog` ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಇದೆ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ.

// Constructor function for Animal
function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  console.log(`${this.name} makes a sound.`);
};

// Constructor function for Dog
function Dog(name, breed) {
  Animal.call(this, name); // Call the parent constructor
  this.breed = breed;
}

// Setting up the prototype chain: Dog.prototype inherits from Animal.prototype
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog; // Correct the constructor property

Dog.prototype.bark = function() {
  console.log(`Woof! My name is ${this.name} and I'm a ${this.breed}.`);
};

const myDog = new Dog("Buddy", "Golden Retriever");

console.log(myDog.name);     // Output: Buddy (found on myDog)
myDog.speak();    // Output: Buddy makes a sound. (found on Dog.prototype via Animal.prototype)
myDog.bark();     // Output: Woof! My name is Buddy and I'm a Golden Retriever. (found on Dog.prototype)

console.log(Object.getPrototypeOf(myDog) === Dog.prototype); // Output: true
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // Output: true
console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // Output: true
console.log(Object.getPrototypeOf(Object.prototype) === null); // Output: true

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• myDog ಗೆ name ಮತ್ತು breed ಎಂಬ ನೇರ ಪ್ರಾಪರ್ಟಿಗಳಿವೆ.
• myDog.speak() ಅನ್ನು ಕರೆದಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ speak ಅನ್ನು myDog ಮೇಲೆ ಹುಡುಕುತ್ತದೆ. ಅದು ಕಂಡುಬರುವುದಿಲ್ಲ.
• ನಂತರ ಅದು Object.getPrototypeOf(myDog) ಅನ್ನು ನೋಡುತ್ತದೆ, ಅದು Dog.prototype ಆಗಿದೆ. speak ಅಲ್ಲಿ ಕಂಡುಬರುವುದಿಲ್ಲ.
• ನಂತರ ಅದು Object.getPrototypeOf(Dog.prototype) ಅನ್ನು ನೋಡುತ್ತದೆ, ಅದು Animal.prototype ಆಗಿದೆ. ಇಲ್ಲಿ, speak ಕಂಡುಬರುತ್ತದೆ! ಫಂಕ್ಷನ್ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು speak ಒಳಗಿನ this myDog ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಯ ಮಾದರಿಗಳು

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಆಂತರಿಕವಾಗಿ ಸಂಪರ್ಕ ಹೊಂದಿದೆ. ಐತಿಹಾಸಿಕವಾಗಿ, ES6 ಕ್ಲಾಸ್‌ಗಳ ಮೊದಲು, ಆಬ್ಜೆಕ್ಟ್ ರಚನೆ ಮತ್ತು ಇನ್ಹೆರಿಟೆನ್ಸ್ ಸಾಧಿಸಲು ಹಲವಾರು ಮಾದರಿಗಳನ್ನು ಬಳಸಲಾಗುತ್ತಿತ್ತು:

1. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳು

ಮೇಲಿನ Animal ಮತ್ತು Dog ಉದಾಹರಣೆಗಳಲ್ಲಿ ನೋಡಿದಂತೆ, ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ಮಾರ್ಗವಾಗಿದೆ. ನೀವು new ಕೀವರ್ಡ್ ಅನ್ನು ಒಂದು ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಬಳಸಿದಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹಲವಾರು ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡುತ್ತದೆ:

1. ಒಂದು ಹೊಸ ಖಾಲಿ ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಯಾಗುತ್ತದೆ.
2. ಈ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ನ prototype ಪ್ರಾಪರ್ಟಿಗೆ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತದೆ (ಅಂದರೆ, newObj.[[Prototype]] = Constructor.prototype).
3. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು this ಗೆ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬೈಂಡ್ ಮಾಡಿ ಕರೆಯಲಾಗುತ್ತದೆ.
4. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸದಿದ್ದರೆ, ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಆಬ್ಜೆಕ್ಟ್ (this) ಅನ್ನು ಪರೋಕ್ಷವಾಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪ್ರೊಟೊಟೈಪ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಹಂಚಿಕೆಯ ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಬಹು ಇನ್‌ಸ್ಟನ್ಸ್‌ಗಳನ್ನು ರಚಿಸಲು ಈ ಮಾದರಿಯು ಶಕ್ತಿಯುತವಾಗಿದೆ.

2. ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳು

ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳು ಸರಳವಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಅವು new ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ ಮತ್ತು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳಂತೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರೊಟೊಟೈಪ್‌ಗೆ ಲಿಂಕ್ ಆಗುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಹಿಂತಿರುಗಿಸಿದ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೆಟ್ ಮಾಡುವ ಮೂಲಕ ಅವು ಪ್ರೊಟೊಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.

function createPerson(name, age) {
  const person = Object.create(personFactory.prototype);
  person.name = name;
  person.age = age;
  return person;
}

personFactory.prototype.greet = function() {
  console.log(`Hello, I'm ${this.name}`);
};

const john = createPerson("John", 25);
john.greet(); // Output: Hello, I'm John

Object.create() ಇಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಮೆಥಡ್ ಆಗಿದೆ. ಇದು ಒಂದು ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಆಗಿ ಬಳಸುತ್ತದೆ. ಇದು ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಮೇಲೆ ಸ್ಪಷ್ಟ ನಿಯಂತ್ರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

3. `Object.create()`

ಮೇಲೆ ಸೂಚಿಸಿದಂತೆ, Object.create(proto, [propertiesObject]) ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರೊಟೊಟೈಪ್‌ನೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಮೂಲಭೂತ ಸಾಧನವಾಗಿದೆ. ಇದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬೈಪಾಸ್ ಮಾಡಲು ಮತ್ತು ನೇರವಾಗಿ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಸೆಟ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

const personPrototype = {
  greet: function() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

// Create a new object 'bob' with 'personPrototype' as its prototype
const bob = Object.create(personPrototype);
bob.name = "Bob";
bob.greet(); // Output: Hello, my name is Bob

// You can even pass properties as a second argument
const charles = Object.create(personPrototype, {
  name: { value: "Charles", writable: true, enumerable: true, configurable: true }
});
charles.greet(); // Output: Hello, my name is Charles

ಪೂರ್ವನಿರ್ಧರಿತ ಪ್ರೊಟೊಟೈಪ್‌ಗಳೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಈ ಮೆಥಡ್ ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾಗಿದೆ, ಇದು ಸುಲಭವಾಗಿ ಬದಲಾಯಿಸಬಹುದಾದ ಇನ್ಹೆರಿಟೆನ್ಸ್ ರಚನೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ES6 ಕ್ಲಾಸ್‌ಗಳು: ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ಶುಗರ್

ES6 ನ ಆಗಮನದೊಂದಿಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ class ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸಿತು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಕ್ಲಾಸ್‌ಗಳು ಪ್ರಾಥಮಿಕವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರೊಟೊಟೈಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಕಾರ್ಯವಿಧಾನದ ಮೇಲೆ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ಶುಗರ್ (ಸುಲಭವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್) ಆಗಿವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಕ್ಲಾಸ್-ಆಧಾರಿತ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಭಾಷೆಗಳಿಂದ ಬರುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅವು ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಪರಿಚಿತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ.

// Using ES6 class syntax
class AnimalES6 {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class DogES6 extends AnimalES6 {
  constructor(name, breed) {
    super(name); // Calls the parent class constructor
    this.breed = breed;
  }

  bark() {
    console.log(`Woof! My name is ${this.name} and I'm a ${this.breed}.`);
  }
}

const myDogES6 = new DogES6("Rex", "German Shepherd");
myDogES6.speak(); // Output: Rex makes a sound.
myDogES6.bark();  // Output: Woof! My name is Rex and I'm a German Shepherd.

// Under the hood, this still uses prototypes:
console.log(Object.getPrototypeOf(myDogES6) === DogES6.prototype); // Output: true
console.log(Object.getPrototypeOf(DogES6.prototype) === AnimalES6.prototype); // Output: true

ನೀವು ಒಂದು ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದಾಗ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಭೂತವಾಗಿ ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಥಾಪಿಸುತ್ತದೆ:

• constructor ಮೆಥಡ್ ಆಬ್ಜೆಕ್ಟ್ ಇನ್‌ಸ್ಟನ್ಸ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
• ಕ್ಲಾಸ್ ಬಾಡಿಯೊಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮೆಥಡ್‌ಗಳು (speak ಮತ್ತು bark ನಂತಹ) ಆ ಕ್ಲಾಸ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿತವಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ನ prototype ಪ್ರಾಪರ್ಟಿಯ ಮೇಲೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇರಿಸಲಾಗುತ್ತದೆ.
• extends ಕೀವರ್ಡ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಸಂಬಂಧವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಅನ್ನು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಪ್ರೊಟೊಟೈಪ್‌ಗೆ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ.

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಜಾಗತಿಕವಾಗಿ ಏಕೆ ಮುಖ್ಯ?

ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕೇವಲ ಶೈಕ್ಷಣಿಕ ವ್ಯಾಯಾಮವಲ್ಲ; ಇದು ದೃಢವಾದ, ದಕ್ಷ, ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದರ ಮೇಲೆ ಆಳವಾದ ಪರಿಣಾಮಗಳನ್ನು ಬೀರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ:

• ಕಾರ್ಯಕ್ಷಮತೆಯ ಆಪ್ಟಿಮೈಸೇಶನ್: ಪ್ರತಿಯೊಂದು ಆಬ್ಜೆಕ್ಟ್ ಇನ್‌ಸ್ಟನ್ಸ್‌ನಲ್ಲಿ ಮೆಥಡ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಬದಲು ಪ್ರೊಟೊಟೈಪ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ಮೆಮೊರಿಯನ್ನು ಉಳಿಸುತ್ತೀರಿ. ಎಲ್ಲಾ ಇನ್‌ಸ್ಟನ್ಸ್‌ಗಳು ಒಂದೇ ಮೆಥಡ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ, ಇದು ಹೆಚ್ಚು ದಕ್ಷ ಮೆಮೊರಿ ಬಳಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಇದು ಜಗತ್ತಿನಾದ್ಯಂತ ವಿವಿಧ ಸಾಧನಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ಕೋಡ್ ಮರುಬಳಕೆ: ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕೋಡ್ ಮರುಬಳಕೆಯ ಪ್ರಾಥಮಿಕ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಇನ್ಹೆರಿಟೆನ್ಸ್ ನಿಮಗೆ ಸಂಕೀರ್ಣ ಆಬ್ಜೆಕ್ಟ್ ಕ್ರಮಾನುಗತಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು ನಕಲು ಮಾಡದೆ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ. ಅಂತರರಾಷ್ಟ್ರೀಯ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ದೊಡ್ಡ, ವಿತರಿಸಿದ ತಂಡಗಳಿಗೆ ಇದು ಅಮೂಲ್ಯವಾಗಿದೆ.
• ಆಳವಾದ ಡೀಬಗ್ಗಿಂಗ್: ದೋಷಗಳು ಸಂಭವಿಸಿದಾಗ, ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯ ಮೂಲವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇನ್ಹೆರಿಟೆನ್ಸ್, ಸ್ಕೋಪ್ ಮತ್ತು `this` ಬೈಂಡಿಂಗ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಸಮಸ್ಯೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೇಗೆ ಹುಡುಕಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.
• ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು: ಅನೇಕ ಜನಪ್ರಿಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು (ಉದಾ., React, Angular, Vue.js ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳು) ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿವೆ ಅಥವಾ ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ. ಪ್ರೊಟೊಟೈಪ್‌ಗಳ ಬಗ್ಗೆ ದೃಢವಾದ ತಿಳುವಳಿಕೆಯು ಅವುಗಳ ಆಂತರಿಕ ಕಾರ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅವುಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಭಾಷಾ ಅಂತರ್ಕಾರ್ಯಾಚರಣೆ: ಪ್ರೊಟೊಟೈಪ್‌ಗಳೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ನಮ್ಯತೆಯು ಇತರ ಸಿಸ್ಟಮ್‌ಗಳು ಅಥವಾ ಭಾಷೆಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ Node.js ನಂತಹ ಪರಿಸರಗಳಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೇಟಿವ್ ಮಾಡ್ಯೂಲ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ.
• ಪರಿಕಲ್ಪನಾತ್ಮಕ ಸ್ಪಷ್ಟತೆ: ES6 ಕ್ಲಾಸ್‌ಗಳು ಕೆಲವು ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಮರೆಮಾಡಿದರೂ, ಪ್ರೊಟೊಟೈಪ್‌ಗಳ ಮೂಲಭೂತ ತಿಳುವಳಿಕೆಯು ತೆರೆಯ ಹಿಂದೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಗ್ರಹಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಆಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಭೌಗೋಳಿಕ ಸ್ಥಳ ಅಥವಾ ಆದ್ಯತೆಯ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ಲೆಕ್ಕಿಸದೆ, ಎಡ್ಜ್ ಕೇಸ್‌ಗಳು ಮತ್ತು ಸುಧಾರಿತ ಸನ್ನಿವೇಶಗಳನ್ನು ಹೆಚ್ಚು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ನಿಭಾಯಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸದಿದ್ದರೆ ಗೊಂದಲಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿವೆ:

ತಪ್ಪು 1: ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರೊಟೊಟೈಪ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸುವುದು

Array.prototype ಅಥವಾ Object.prototype ನಂತಹ ಅಂತರ್ನಿರ್ಮಿತ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರೊಟೊಟೈಪ್‌ಗಳಲ್ಲಿ ಮೆಥಡ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು ಅಥವಾ ಮಾರ್ಪಡಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ಆಲೋಚನೆಯಾಗಿದೆ. ಇದು ಹೆಸರಿನ ಸಂಘರ್ಷಗಳಿಗೆ ಮತ್ತು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿ ಅಥವಾ ಈ ಪ್ರೊಟೊಟೈಪ್‌ಗಳ ಮೂಲ ನಡವಳಿಕೆಯನ್ನು ಅವಲಂಬಿಸಿರುವ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವಾಗ.

ಉತ್ತಮ ಅಭ್ಯಾಸ: ನಿಮ್ಮ ಸ್ವಂತ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳು, ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳು, ಅಥವಾ ES6 ಕ್ಲಾಸ್‌ಗಳನ್ನು ಬಳಸಿ. ನೀವು ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಬೇಕಾದರೆ, ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ಅಥವಾ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ತಪ್ಪು 2: ತಪ್ಪಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಾಪರ್ಟಿ

ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ಥಾಪಿಸುವಾಗ (ಉದಾ., Dog.prototype = Object.create(Animal.prototype)), ಹೊಸ ಪ್ರೊಟೊಟೈಪ್‌ನ (Dog.prototype) constructor ಪ್ರಾಪರ್ಟಿಯು ಮೂಲ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ (Animal) ಸೂಚಿಸುತ್ತದೆ. ಇದು `instanceof` ಪರಿಶೀಲನೆಗಳು ಮತ್ತು ಆತ್ಮಾವಲೋಕನದೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು.

ಉತ್ತಮ ಅಭ್ಯಾಸ: ಇನ್ಹೆರಿಟೆನ್ಸ್ ಸ್ಥಾಪಿಸಿದ ನಂತರ ಯಾವಾಗಲೂ constructor ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಮರುಹೊಂದಿಸಿ:

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

ತಪ್ಪು 3: `this` ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಪ್ರೊಟೊಟೈಪ್ ಮೆಥಡ್‌ಗಳಲ್ಲಿನ this ನ ನಡವಳಿಕೆಯು ನಿರ್ಣಾಯಕವಾಗಿದೆ. this ಯಾವಾಗಲೂ ಮೆಥಡ್ ಅನ್ನು ಯಾವ ಆಬ್ಜೆಕ್ಟ್‌ನ ಮೇಲೆ ಕರೆಯಲಾಗಿದೆಯೋ ಅದನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮೆಥಡ್ ಅನ್ನು ಎಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನಲ್ಲ. ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನಾದ್ಯಂತ ಮೆಥಡ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದಕ್ಕೆ ಇದು ಮೂಲಭೂತವಾಗಿದೆ.

ಉತ್ತಮ ಅಭ್ಯಾಸ: ಮೆಥಡ್‌ಗಳನ್ನು ಹೇಗೆ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಗಮನವಿರಲಿ. ನೀವು this ಸಂದರ್ಭವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೆಟ್ ಮಾಡಬೇಕಾದರೆ `.call()`, `.apply()`, ಅಥವಾ `.bind()` ಬಳಸಿ, ವಿಶೇಷವಾಗಿ ಮೆಥಡ್‌ಗಳನ್ನು ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳಾಗಿ ರವಾನಿಸುವಾಗ.

ತಪ್ಪು 4: ಇತರ ಭಾಷೆಗಳಲ್ಲಿನ ಕ್ಲಾಸ್‌ಗಳೊಂದಿಗೆ ಗೊಂದಲ

ಕ್ಲಾಸಿಕಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್‌ಗೆ (Java ಅಥವಾ C++ ನಂತಹ) ಒಗ್ಗಿಕೊಂಡಿರುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಮಾದರಿಯು ಆರಂಭದಲ್ಲಿ ಅಸಹಜವಾಗಿ ಕಾಣಿಸಬಹುದು. ES6 ಕ್ಲಾಸ್‌ಗಳು ಒಂದು ಮುಖವಾಡ ಎಂದು ನೆನಪಿಡಿ; ಆಧಾರವಾಗಿರುವ ಕಾರ್ಯವಿಧಾನವು ಇನ್ನೂ ಪ್ರೊಟೊಟೈಪ್‌ಗಳೇ ಆಗಿದೆ.

ಉತ್ತಮ ಅಭ್ಯಾಸ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪಲ್ ಸ್ವರೂಪವನ್ನು ಅಪ್ಪಿಕೊಳ್ಳಿ. ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ತಮ್ಮ ಪ್ರೊಟೊಟೈಪ್‌ಗಳ ಮೂಲಕ ಪ್ರಾಪರ್ಟಿ ಹುಡುಕಾಟಗಳನ್ನು ಹೇಗೆ ನಿಯೋಜಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರ ಮೇಲೆ ಗಮನಹರಿಸಿ.

ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಮೀರಿ: ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳು

`instanceof` ಆಪರೇಟರ್

instanceof ಆಪರೇಟರ್ ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ prototype ಪ್ರಾಪರ್ಟಿ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದು ಪ್ರೊಟೊಟೈಪಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಟೈಪ್ ಪರಿಶೀಲನೆಗೆ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ.

console.log(myDog instanceof Dog);      // Output: true
console.log(myDog instanceof Animal);   // Output: true
console.log(myDog instanceof Object);   // Output: true
console.log(myDog instanceof Array);    // Output: false

`isPrototypeOf()` ಮೆಥಡ್

Object.prototype.isPrototypeOf() ಮೆಥಡ್ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತೊಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನಲ್ಲಿ ಎಲ್ಲಾದರೂ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

console.log(Dog.prototype.isPrototypeOf(myDog));    // Output: true
console.log(Animal.prototype.isPrototypeOf(myDog)); // Output: true
console.log(Object.prototype.isPrototypeOf(myDog)); // Output: true

ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮರೆಮಾಡುವುದು (Shadowing)

ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಮೇಲಿನ ಪ್ರಾಪರ್ಟಿಯು ಅದರ ಪ್ರೊಟೊಟೈಪ್ ಮೇಲಿನ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಮರೆಮಾಡುತ್ತದೆ (shadow) ಎಂದು ಹೇಳಲಾಗುತ್ತದೆ, ಅದು ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಿದ್ದರೆ. ನೀವು ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ, ಆಬ್ಜೆಕ್ಟ್ ಮೇಲಿನದನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಪ್ರೊಟೊಟೈಪ್ ಮೇಲಿನದನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ (ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಅಳಿಸುವವರೆಗೆ). ಇದು ಡೇಟಾ ಪ್ರಾಪರ್ಟಿಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳೆರಡಕ್ಕೂ ಅನ್ವಯಿಸುತ್ತದೆ.

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log(`Hello from Person: ${this.name}`);
  }
}

class Employee extends Person {
  constructor(name, id) {
    super(name);
    this.id = id;
  }

  // Shadowing the greet method from Person
  greet() {
    console.log(`Hello from Employee: ${this.name}, ID: ${this.id}`);
  }
}

const emp = new Employee("Jane", "E123");
emp.greet(); // Output: Hello from Employee: Jane, ID: E123

// To call the parent's greet method, we'd need super.greet()

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಒಂದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು, ಇದು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗುತ್ತದೆ, ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅನ್ನು ಹೇಗೆ ಸಾಧಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಆಧಾರವಾಗಿದೆ. ES6 ಕ್ಲಾಸ್‌ಗಳಂತಹ ಆಧುನಿಕ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅದರ ಬಳಕೆಯನ್ನು ಸರಳಗೊಳಿಸಿದರೂ, ಯಾವುದೇ ಗಂಭೀರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗೆ ಪ್ರೊಟೊಟೈಪ್‌ಗಳ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅತ್ಯಗತ್ಯ. ಈ ಪರಿಕಲ್ಪನೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದಕ್ಷ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ, ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಪಡೆಯುತ್ತೀರಿ, ಇದು ಜಾಗತಿಕ ಯೋಜನೆಗಳಲ್ಲಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಹಕರಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನೀವು ಬಹುರಾಷ್ಟ್ರೀಯ ನಿಗಮಕ್ಕಾಗಿ ಅಥವಾ ಅಂತರರಾಷ್ಟ್ರೀಯ ಬಳಕೆದಾರರನ್ನು ಹೊಂದಿರುವ ಸಣ್ಣ ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ಗಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿರಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್‌ನ ದೃಢವಾದ ತಿಳುವಳಿಕೆಯು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಶಸ್ತ್ರಾಗಾರದಲ್ಲಿ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಅನ್ವೇಷಿಸುತ್ತಿರಿ, ಕಲಿಯುತ್ತಿರಿ, ಮತ್ತು ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!